package com.example.sxt_practise.java并发编程;

/**
 * 守护线程
 * 默认情况下,java进程需要等待所有线程都运行结束,才会结束.其他非守护线程结束了,即使守护线程的代码没有执行完,也会强制结束
 * 垃圾回收器线程和Tomcat的Acceptor,Poller线程
 * @author gaofeng
 * date 2022年02月07日 20:54
 */
public class TestDaemon {


   /* static int  COUNT = 0 ;

    static Object lock = new Object() ;*/
    /**
     * 两个线程操作共享变量
     *
     * COUNT可能为正,为负,为0
     * 问题在于多个线程访问共享资源
     *  1.多个线程在读共享资源其实也没问题
     *  2.在多个线程对共享资源读写操作时发生指令交替,就会出现问题
     * 一个代码块内如果存在对共享资源的多线程读写操作,称这段代码块为临界区
     *
     * 竞态条件
     * 多个线程在临界区内执行,由于代码的执行序列不同而导致结果无法预测,称之为发生了竞态条件
     *
     * synchronized:采用互斥的方式让同一时刻至多有一个线程能持有对象锁
     *  实际上是用对象锁保证了临界区代码块的原子性
     * @author gaofeng
     * @date  2022/2/11 19:48
     * @param
     * @param args
     * @return
     */

    static Room room = new Room() ;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            /*for (int i = 0; i < 5000; i++) {
                room.decrease();
            }*/
            try {
                room.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }) ;

        Thread t2 = new Thread(() -> {
            /*for (int i = 0; i < 5000; i++) {
            room.increment();
            }*/
            room.decrease();
        }) ;

        t1.start();
        t2.start();

       /* t1.join();
        t2.join();*/

        /*System.out.println(room.getCOUNT());*/
    }
}


class Room {

    private static Integer COUNT = 0;

    public synchronized void increment() throws InterruptedException {
        /*synchronized (this) {
            COUNT ++ ;
        }*/
        Thread.sleep(1000);
        System.out.println(1);
    }

    public synchronized void decrease() {
        /*synchronized (this) {
            COUNT -- ;
        }*/
        System.out.println(2);
    }

    public synchronized Integer getCOUNT() {
        synchronized (this) {
            return COUNT ;
        }
    }
}
